<?xml version="1.0"?>
<doc>
    <assembly>
        <name>MoreLinq</name>
    </assembly>
    <members>
        <member name="T:MoreLinq.MoreEnumerable">
            <summary>
            Provides a set of static methods for querying objects that 
            implement <see cref="T:System.Collections.Generic.IEnumerable`1"/>. The actual methods
            are implemented in files reflecting the method name.
            </summary>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.AssertCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Asserts that a source sequence contains a given count of elements.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="count">Count to assert.</param>
            <returns>
            Returns the original sequence as long it is contains the
            number of elements specified by <paramref name="count"/>.
            Otherwise it throws <see cref="T:System.Exception"/>.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.AssertCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,System.Int32,System.Exception})">
            <summary>
            Asserts that a source sequence contains a given count of elements.
            A parameter specifies the exception to be thrown.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="count">Count to assert.</param>
            <param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
            <returns>
            Returns the original sequence as long it is contains the
            number of elements specified by <paramref name="count"/>.
            Otherwise it throws the <see cref="T:System.Exception"/> object
            returned by calling <paramref name="errorSelector"/>.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Concat``1(``0,System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns a sequence consisting of the head element and the given tail elements.
            This operator uses deferred execution and streams its results.
            </summary>
            <typeparam name="T">Type of sequence</typeparam>
            <param name="head">Head element of the new sequence.</param>
            <param name="tail">All elements of the tail. Must not be null.</param>
            <returns>A sequence consisting of the head elements and the given tail elements.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Returns a sequence consisting of the head elements and the given tail element.
            This operator uses deferred execution and streams its results.
            </summary>
            <typeparam name="T">Type of sequence</typeparam>
            <param name="head">All elements of the head. Must not be null.</param>
            <param name="tail">Tail element of the new sequence.</param>
            <returns>A sequence consisting of the head elements and the given tail element.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Consume``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Completely consumes the given sequence. This method uses immediate execution,
            and doesn't store any data during execution.
            </summary>
            <typeparam name="T">Element type of the sequence</typeparam>
            <param name="source">Source to consume</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Batch``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Batches the source sequence into sized buckets.
            </summary>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Batches the source sequence into sized buckets that are then
            transformed into results.
            </summary>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Trace``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Traces the elements of a source sequence for diagnostics.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence</typeparam>
            <param name="source">Source sequence whose elements to trace.</param>
            <returns>
            Return the source sequence unmodified.
            </returns>
            <remarks>
            This a pass-through operator that uses deferred execution and 
            streams the results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Trace``1(System.Collections.Generic.IEnumerable{``0},System.String)">
            <summary>
            Traces the elements of a source sequence for diagnostics using
            custom formatting.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence</typeparam>
            <param name="source">Source sequence whose elements to trace.</param>
            <param name="format">
            String to use to format the trace message. If null then the
            element value becomes the traced message.
            </param>
            <returns>
            Return the source sequence unmodified.
            </returns>
            <remarks>
            This a pass-through operator that uses deferred execution and 
            streams the results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Trace``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.String})">
            <summary>
            Traces the elements of a source sequence for diagnostics using
            a custom formatter.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence</typeparam>
            <param name="source">Source sequence whose elements to trace.</param>
            <param name="formatter">Function used to format each source element into a string.</param>
            <returns>
            Return the source sequence unmodified.
            </returns>
            <remarks>
            This a pass-through operator that uses deferred execution and 
            streams the results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Pipe``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
            <summary>
            Executes the given action on each element in the source sequence
            and yields it.
            </summary>
            <remarks>
            The returned sequence is essentially a duplicate of
            the original, but with the extra action being executed while the
            sequence is evaluated. The action is always taken before the element
            is yielded, so any changes made by the action will be visible in the
            returned sequence. This operator executes lazily, and with deferred
            execution.
            </remarks>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="source">The sequence of elements</param>
            <param name="action">The action to execute on each element</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
            <summary>
            Immediately executes the given action on each element in the source sequence.
            </summary>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="source">The sequence of elements</param>
            <param name="action">The action to execute on each element</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns all distinct elements of the given source, where "distinctness"
            is determined via a projection and the default eqaulity comparer for the projected type.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results, although
            a set of already-seen keys is retained. If a key is seen multiple times,
            only the first element with that key is returned.
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="keySelector">Projection for determining "distinctness"</param>
            <returns>A sequence consisting of distinct elements from the source sequence,
            comparing them by the specified key projection.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Returns all distinct elements of the given source, where "distinctness"
            is determined via a projection and the specified comparer for the projected type.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results, although
            a set of already-seen keys is retained. If a key is seen multiple times,
            only the first element with that key is returned.
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="keySelector">Projection for determining "distinctness"</param>
            <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
            If null, the default equality comparer for <c>TSource</c> is used.</param>
            <returns>A sequence consisting of distinct elements from the source sequence,
            comparing them by the specified key projection.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.GenerateByIndex``1(System.Func{System.Int32,``0})">
            <summary>
            Returns a sequence of values based on indexes.
            </summary>
            <remarks>
            The sequence is (practically) infinite
            - the index ranges from 0 to <c>int.MaxValue</c> inclusive. This function defers
            execution and streams the results.
            </remarks>
            <typeparam name="TResult">Type of result to generate</typeparam>
            <param name="generator">Generation function to apply to each index</param>
            <returns>A sequence </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Generate``1(``0,System.Func{``0,``0})">
            <summary>
            Returns a sequence of values consecutively generated by a generator function.
            </summary>
            <typeparam name="TResult">Type of elements to generate.</typeparam>
            <param name="initial">Value of first element in sequence</param>
            <param name="generator">
            Generator function which takes the previous series element and uses it to generate the next element.
            </param>
            <remarks>
            This function defers element generation until needed and streams the results.
            </remarks>
            <example>
            <code>
            IEnumerable&lt;int&gt; result = Sequence.Generate(2, n => n * n).Take(6);
            </code>
            The <c>result</c> variable, when iterated over, will yield 2, 4, 8, 16, 32, and 64, in turn.
            </example>        
        </member>
        <member name="M:MoreLinq.MoreEnumerable.TakeEvery``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Returns every N-th element of a source sequence.
            </summary>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <param name="source">Source sequence</param>
            <param name="step">Steps in which to partition source</param>
            <remarks>
            This operator uses deferred execution and streams the results.
            </remarks>
            <example>
            <code>
            int[] numbers = { 1, 2, 3, 4, 5 };
            IEnumerable&lt;int&gt; result = numbers.Every(2);
            </code>
            The <c>result</c> variable, when iterated over, will yield 1, 3 and 5, in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Zip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
            <summary>
            Returns a projection of tuples, where each tuple contains the N-th element 
            from each of the argument sequences.
            </summary>
            <remarks>
            If the two input sequences are of different lengths, the result sequence 
            is terminated as soon as the shortest input sequence is exhausted.
            </remarks>
            <example>
            <code>
            int[] numbers = { 1, 2, 3 };
            string[] letters = { "A", "B", "C", "D" };
            var zipped = numbers.Zip(letters, (n, l) => n + l);
            </code>
            The <c>zipped</c> variable, when iterated over, will yield "1A", "2B", "3C", in turn.
            </example>
            <typeparam name="TFirst">Type of elements in first sequence</typeparam>
            <typeparam name="TSecond">Type of elements in second sequence</typeparam>
            <typeparam name="TResult">Type of elements in result sequence</typeparam>
            <param name="first">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="resultSelector">Function to apply to each pair of elements</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.EquiZip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
            <summary>
            Returns a projection of tuples, where each tuple contains the N-th element 
            from each of the argument sequences.
            </summary>
            <remarks>
            If the two input sequences are of different lengths then 
            <see cref="T:System.InvalidOperationException"/> is thrown.
            </remarks>
            <example>
            <code>
            int[] numbers = { 1, 2, 3, 4 };
            string[] letters = { "A", "B", "C", "D" };
            var zipped = numbers.EquiZip(letters, (n, l) =&gt; n + l);
            </code>
            The <c>zipped</c> variable, when iterated over, will yield "1A", "2B", "3C", "4D" in turn.
            </example>
            <typeparam name="TFirst">Type of elements in first sequence</typeparam>
            <typeparam name="TSecond">Type of elements in second sequence</typeparam>
            <typeparam name="TResult">Type of elements in result sequence</typeparam>
            <param name="first">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="resultSelector">Function to apply to each pair of elements</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ZipLongest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
            <summary>
            Returns a projection of tuples, where each tuple contains the N-th element 
            from each of the argument sequences.
            </summary>
            <remarks>
            If the two input sequences are of different lengths then the result 
            sequence will always be as long as the longer of the two input sequences.
            The default value of the shorter sequence element type is used for padding.
            </remarks>
            <example>
            <code>
            int[] numbers = { 1, 2, 3 };
            string[] letters = { "A", "B", "C", "D" };
            var zipped = numbers.EquiZip(letters, (n, l) => n + l);
            </code>
            The <c>zipped</c> variable, when iterated over, will yield "1A", "2B", "3C", "0D" in turn.
            </example>
            <typeparam name="TFirst">Type of elements in first sequence</typeparam>
            <typeparam name="TSecond">Type of elements in second sequence</typeparam>
            <typeparam name="TResult">Type of elements in result sequence</typeparam>
            <param name="first">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="resultSelector">Function to apply to each pair of elements</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
            <summary>
            Peforms a scan (inclusive prefix sum) on a sequence of elements.
            </summary>
            <remarks>
            An inclusive prefix sum returns an equal-length sequence where the
            N-th element is the sum of the first N input elements. More
            generally, the scan allows any commutative binary operation, not
            just a sum.
            </remarks>
            <example>
            <code>
            Func&lt;int, int, int&gt; plus = (a, b) =&gt; a + b;
            int[] values = { 1, 2, 3, 4 };
            IEnumerable&lt;int&gt; prescan = values.PreScan(plus, 0);
            IEnumerable&lt;int&gt; scan = values.Scan(plus; a + b);
            IEnumerable&lt;int&gt; result = values.Zip(prescan, plus);
            </code>
            <c>prescan</c> will yield <c>{ 0, 1, 3, 6 }</c>, while <c>scan</c>
            and <c>result</c> will both yield <c>{ 1, 3, 6, 10 }</c>. This
            shows the relationship between the inclusive and exclusive prefix sum.
            </example>
            <typeparam name="TSource">Type of elements in source sequence</typeparam>
            <param name="source">Source sequence</param>
            <param name="transformation">Transformation operation</param>
            <returns>The scanned sequence</returns>
            <exception cref="T:System.InvalidOperationException">If <paramref name="source"/> is empty.</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PreScan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0},``0)">
            <summary>
            Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
            </summary>
            <remarks>
            An exclusive prefix sum returns an equal-length sequence where the
            N-th element is the sum of the first N-1 input elements (the first
            element is a special case, it is set to the identity). More
            generally, the pre-scan allows any commutative binary operation,
            not just a sum.
            </remarks>
            <typeparam name="TSource">Type of elements in source sequence</typeparam>
            <param name="source">Source sequence</param>
            <param name="transformation">Transformation operation</param>
            <param name="identity">Identity element (see remarks)</param>
            <returns>The scanned sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Pads a sequence with default values if it is narrower (shorter 
            in length) than a given width.
            </summary>
            <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The sequence to pad.</param>
            <param name="width">The width/length below which to pad.</param>
            <returns>
            Returns a sequence that is at least as wide/long as the width/length
            specified by the <paramref name="width"/> parameter.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code>
            int[] numbers = { 123, 456, 789 };
            IEnumerable&lt;int&gt; result = numbers.Pad(5);
            </code>
            The <c>result</c> variable, when iterated over, will yield 
            123, 456, 789 and two zeroes, in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32,``0)">
            <summary>
            Pads a sequence with a given filler value if it is narrower (shorter 
            in length) than a given width.
            </summary>
            <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The sequence to pad.</param>
            <param name="width">The width/length below which to pad.</param>
            <param name="padding">The value to use for padding.</param>
            <returns>
            Returns a sequence that is at least as wide/long as the width/length
            specified by the <paramref name="width"/> parameter.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code>
            int[] numbers = { 123, 456, 789 };
            IEnumerable&lt;int&gt; result = numbers.Pad(5, -1);
            </code>
            The <c>result</c> variable, when iterated over, will yield 
            123, 456, and 789 followed by two occurrences of -1, in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,``0})">
            <summary>
            Pads a sequence with a dynamic filler value if it is narrower (shorter 
            in length) than a given width.
            </summary>
            <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The sequence to pad.</param>
            <param name="width">The width/length below which to pad.</param>
            <param name="paddingSelector">Function to calculate padding.</param>
            <returns>
            Returns a sequence that is at least as wide/long as the width/length
            specified by the <paramref name="width"/> parameter.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code>
            int[] numbers = { 0, 1, 2 };
            IEnumerable&lt;int&gt; result = numbers.Pad(5, i => -i);
            </code>
            The <c>result</c> variable, when iterated over, will yield 
            0, 1, 2, -3 and -4, in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Prepends a single value to a sequence.
            </summary>
            <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The sequence to prepend to.</param>
            <param name="value">The value to prepend.</param>
            <returns>
            Returns a sequence where a value is prepended to it.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <code>
            int[] numbers = { 1, 2, 3 };
            IEnumerable&lt;int&gt; result = numbers.Prepend(0);
            </code>
            The <c>result</c> variable, when iterated over, will yield 
            0, 1, 2 and 3, in turn.
        </member>
        <member name="M:MoreLinq.MoreEnumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns the minimal element of the given sequence, based on
            the given projection.
            </summary>
            <remarks>
            If more than one element has the minimal projected value, the first
            one encountered will be returned. This overload uses the default comparer
            for the projected type. This operator uses immediate execution, but
            only buffers a single result (the current minimal element).
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="selector">Selector to use to pick the results to compare</param>
            <returns>The minimal element, according to the projection.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> is empty</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Returns the minimal element of the given sequence, based on
            the given projection and the specified comparer for projected values.
            </summary>
            <remarks>
            If more than one element has the minimal projected value, the first
            one encountered will be returned. This overload uses the default comparer
            for the projected type. This operator uses immediate execution, but
            only buffers a single result (the current minimal element).
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="selector">Selector to use to pick the results to compare</param>
            <param name="comparer">Comparer to use to compare projected values</param>
            <returns>The minimal element, according to the projection.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/>, <paramref name="selector"/> 
            or <paramref name="comparer"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> is empty</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns the maximal element of the given sequence, based on
            the given projection.
            </summary>
            <remarks>
            If more than one element has the maximal projected value, the first
            one encountered will be returned. This overload uses the default comparer
            for the projected type. This operator uses immediate execution, but
            only buffers a single result (the current maximal element).
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="selector">Selector to use to pick the results to compare</param>
            <returns>The maximal element, according to the projection.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> is empty</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Returns the maximal element of the given sequence, based on
            the given projection and the specified comparer for projected values. 
            </summary>
            <remarks>
            If more than one element has the maximal projected value, the first
            one encountered will be returned. This overload uses the default comparer
            for the projected type. This operator uses immediate execution, but
            only buffers a single result (the current maximal element).
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="selector">Selector to use to pick the results to compare</param>
            <param name="comparer">Comparer to use to compare projected values</param>
            <returns>The maximal element, according to the projection.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/>, <paramref name="selector"/> 
            or <paramref name="comparer"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> is empty</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.SingleOrFallback``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0})">
            <summary>
            Returns the single element in the given sequence, or the result
            of executing a fallback delegate if the sequence is empty.
            </summary>
            <remarks>
            The fallback delegate is not executed if the sequence is non-empty.
            </remarks>
            <typeparam name="T">Element type of sequence</typeparam>
            <param name="source">The source sequence</param>
            <param name="fallback">The fallback delegate to execute if the sequence is empty</param>
            <exception cref="T:System.ArgumentNullException">source or fallback is null</exception>
            <exception cref="T:System.InvalidOperationException">The sequence has more than one element</exception>
            <returns>The single element in the sequence, or the result of calling the
            fallback delegate if the sequence is empty.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <typeparam name="TSource">Type of element in the source sequence</typeparam>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString``1(System.Collections.Generic.IEnumerable{``0},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <typeparam name="TSource">Type of element in the source sequence</typeparam>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="T:MoreLinq.MoreEnumerable.ImbalancedZipStrategy">
            <summary>
            Strategy determining the handling of the case where the inputs are of
            unequal lengths.
            </summary>
        </member>
        <member name="F:MoreLinq.MoreEnumerable.ImbalancedZipStrategy.Truncate">
            <summary>
            The result sequence ends when either input sequence is exhausted.
            </summary>
        </member>
        <member name="F:MoreLinq.MoreEnumerable.ImbalancedZipStrategy.Pad">
            <summary>
            The result sequence ends when both sequences are exhausted. The 
            shorter sequence is effectively "padded" at the end with the default
            value for its element type.
            </summary>
        </member>
        <member name="F:MoreLinq.MoreEnumerable.ImbalancedZipStrategy.Fail">
            <summary>
            <see cref="T:System.InvalidOperationException"/> is thrown if one sequence
            is exhausted but not the other.
            </summary>
        </member>
        <member name="T:MoreLinq.SequenceException">
            <summary>
            The exception that is thrown for a sequence that fails a condition.
            </summary>
        </member>
        <member name="M:MoreLinq.SequenceException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class. 
            </summary>
        </member>
        <member name="M:MoreLinq.SequenceException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
            with a given error message. 
            </summary>
            <param name="message">A message that describes the error.</param>
        </member>
        <member name="M:MoreLinq.SequenceException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
            with a given error message and a reference to the inner exception
            that is the cause of the exception.
            </summary>
            <param name="message">A message that describes the error.</param>
            <param name="innerException">The exception that is the cause of the current exception.</param>
        </member>
        <member name="M:MoreLinq.SequenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
            with serialized data.
            </summary>
            <param name="info">The object that holds the serialized object data.</param>
            <param name="context">The contextual information about the source or destination.</param>
        </member>
        <member name="T:MoreLinq.ThrowHelper">
            <summary>
            Helper methods to make it easier to throw exceptions.
            </summary>
        </member>
    </members>
</doc>
